﻿using System.Web.Mvc;
using zeus.Core;
using SharpArch.Web.NHibernate;
using SharpArch.Core;
using SharpArch.Core.PersistenceSupport;
using System.Collections.Generic;
using Webdiyer.WebControls.Mvc;
using System;
using System.Linq;
using zeus.Core.RepositoryInterfaces;
using zeus.Web.Controllers.Helpers;

namespace zeus.Web.Controllers
{
    [HandleError]
    public class PlanesController : Controller
    {
        #region Constructor
        private readonly IRepository<Planes> planesRepository;
        private readonly IRepository<PlanCliente> planClienteRepository;
        private readonly IRepository<Cliente> clienteRepository;
        private readonly IRepository<Peridiocidad> peridiocidadRepository;
        private readonly IRepository<Intervalo> intervaloRepository;
        private readonly IUsuarioRepository usuarioRepository;
        private readonly IRepository<PlanDisponible> planDisponibleRepository;
        private readonly IRepository<Grupo> grupoRepository;
        private readonly IUnidadRepository unidadRepository;
        private readonly IRepository<TipoEvento> tipoEventoRepository;
        private readonly IRepository<TipoAlerta> tipoAlertaRepository;
        private readonly IRepository<TipoDetalle> tipoDetalleRepository;
        private readonly IPoligonoRepository poligonoRepository;
        private readonly IRepository<PlanEvento> planEventoRepository;

        public PlanesController(IRepository<Planes> planesRepository,
            IRepository<PlanCliente> planClienteRepository,
            IRepository<Cliente> clienteRepository,
            IRepository<Peridiocidad> peridiocidadRepository,
            IRepository<Intervalo> intervaloRepository,
            IUsuarioRepository usuarioRepository,
            IRepository<PlanDisponible> planDisponibleRepository,
            IRepository<Grupo> grupoRepository,
            IUnidadRepository unidadRepository,
            IRepository<TipoEvento> tipoEventoRepository,
            IRepository<TipoAlerta> tipoAlertaRepository,
            IRepository<TipoDetalle> tipoDetalleRepository,
            IPoligonoRepository poligonoRepository,
            IRepository<PlanEvento> planEventoRepository)
        {
            Check.Require(planEventoRepository != null, "planEventoRepository may not be null");
            this.planEventoRepository = planEventoRepository;

            Check.Require(poligonoRepository != null, "poligonoRepository may not be null");
            this.poligonoRepository = poligonoRepository;

            Check.Require(tipoEventoRepository != null, "tipoEventoRepository may not be null");
            this.tipoEventoRepository = tipoEventoRepository;

            Check.Require(tipoAlertaRepository != null, "tipoAlertaRepository may not be null");
            this.tipoAlertaRepository = tipoAlertaRepository;

            Check.Require(tipoDetalleRepository != null, "tipoDetalleRepository may not be null");
            this.tipoDetalleRepository = tipoDetalleRepository;

            Check.Require(unidadRepository != null, "unidadRepository may not be null");
            this.unidadRepository = unidadRepository;

            Check.Require(grupoRepository != null, "grupoRepository may not be null");
            this.grupoRepository = grupoRepository;

            Check.Require(planDisponibleRepository != null, "planDisponibleRepository may not be null");
            this.planDisponibleRepository = planDisponibleRepository;

            Check.Require(usuarioRepository != null, "usuarioRepository may not be null");
            this.usuarioRepository = usuarioRepository;

            Check.Require(peridiocidadRepository != null, "peridiocidadRepository may not be null");
            this.peridiocidadRepository = peridiocidadRepository;

            Check.Require(intervaloRepository != null, "intervaloRepository may not be null");
            this.intervaloRepository = intervaloRepository;

            Check.Require(clienteRepository != null, "clienteRepository may not be null");
            this.clienteRepository = clienteRepository;

            Check.Require(planClienteRepository != null, "planClienteRepository may not be null");
            this.planClienteRepository = planClienteRepository;

            Check.Require(planesRepository != null, "planesRepository may not be null");
            this.planesRepository = planesRepository;
        }

        public WorkingSession workingSession
        {
            get
            {
                if (Session["WorkingSession"] == null)
                    throw new SessionExpiredException();
                return Session["WorkingSession"] as WorkingSession;
            }
            set
            {
                Session["WorkingSession"] = value;
            }
        }
        #endregion

        [Transaction]
        public ActionResult Index()
        {
            //if (!usuarioRepository.IsInRole(User.Identity.Name, "admin,cliente"))
            //         return RedirectToAction("Error", "Shared");
            try
            {               
                return View();
            }
            catch (PreconditionException ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
            catch (SessionExpiredException)
            {
                TempData["ErrorMessage"] = "Sesión Expirada!";
                TempData["Expire"] = true;
                return RedirectToAction("Error", "Shared");
            }
            catch (Exception ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }

        }

        #region Planes Basico

        /// <summary>
        /// Listado de planes disponibles para todos los clientes.
        /// </summary>
        /// <returns></returns>
        [Transaction, Authorize]
        public ActionResult Basico()
        {
            if (!usuarioRepository.IsInRole(User.Identity.Name, "admin,cliente"))
                return RedirectToAction("NoAutorizado", "Shared");

            try
            {
                Dictionary<string, object> filtro = new Dictionary<string, object>();
                filtro.Add("Activo", true);
                IList<Planes> planes = planesRepository.FindAll(filtro);

                return View(planes);
            }
            catch (PreconditionException ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
            catch (SessionExpiredException)
            {
                TempData["ErrorMessage"] = "Sesión Expirada!";
                TempData["Expire"] = true;
                return RedirectToAction("Error", "Shared");
            }
            catch (Exception ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
        }
        
        /// <summary>
        /// Metodo GET para editar un plan.
        /// </summary>
        /// <param name="CodigoPlan"></param>
        /// <returns></returns>
        [Transaction, Authorize]
        public ActionResult EditarPlan(int? CodigoPlan)
        {
            if (!usuarioRepository.IsInRole(User.Identity.Name, "admin,cliente"))
                return RedirectToAction("NoAutorizado", "Shared");

            try
            {
                Check.Require(CodigoPlan != null , "Id incorrecto");

                Dictionary<string, object> filtro = new Dictionary<string, object>();
                filtro.Add("CodigoCliente", workingSession.Usuario.CodigoCliente);
                filtro.Add("CodigoPlan", CodigoPlan);

                PlanCliente planCliente = planClienteRepository.FindAll(filtro).FirstOrDefault() ;
                if (planCliente == null)
                {
                    planCliente = new PlanCliente();
                    planCliente.Planes = planesRepository.Get(CodigoPlan.Value);
                    planCliente.Cliente = workingSession.Usuario.Cliente;                    
                    planCliente.Activo = true;

                    planClienteRepository.SaveOrUpdate(planCliente);
                }

                InicializarCombosBasico(planCliente);

                return View(planCliente);
            }
            catch (PreconditionException ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
            catch (SessionExpiredException)
            {
                TempData["ErrorMessage"] = "Sesión Expirada!";
                TempData["Expire"] = true;
                return RedirectToAction("Error", "Shared");
            }
            catch (Exception ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
        }

        /// <summary>
        /// Metodo POST para editar un plan
        /// </summary>
        /// <param name="CodigoPlan"></param>
        /// <param name="planCliente"></param>
        /// <returns></returns>
        [Transaction, HttpPost, Authorize]
        public ActionResult EditarPlan(int CodigoPlan, PlanCliente planCliente)
        {
            // Determinar si tiene autorización
            if (!usuarioRepository.IsInRole(User.Identity.Name, "admin,cliente"))
                return RedirectToAction("NoAutorizado", "Shared");

            try
            {
                if (ModelState.IsValid && planCliente.IsValid())
                {
                    Dictionary<string, object> filtro = new Dictionary<string, object>();
                    filtro.Add("CodigoCliente", workingSession.Usuario.CodigoCliente);
                    filtro.Add("CodigoPlan", CodigoPlan);

                    PlanCliente planClienteUpdated = planClienteRepository.FindAll(filtro).FirstOrDefault();

                    Check.Require(planClienteUpdated != null, "No se pudo recuperar el plan del cliente");
                                        
                    UpdateModel(planClienteUpdated);

                    // Eliminar todos los usuarios
                    usuarioRepository.DeleteAllPlanDisponible(planClienteUpdated);
                    
                    #region Agregar Usuarios
                    if (!string.IsNullOrEmpty(planCliente.UsuariosHidden))
                    {
                        string[] selectedUsuarios = planCliente.UsuariosHidden.Split(',');

                        // Insertar usuarios seleccionados
                        foreach (var item in selectedUsuarios)
                        {
                            PlanDisponible planDisponible = new PlanDisponible()
                            {
                                Unidad = Convert.ToInt32(item) > 0 ? unidadRepository.Get(Convert.ToInt32(item)) : null,
                                Grupo = Convert.ToInt32(item) > 0 ? null : grupoRepository.Get(Convert.ToInt32(item) * -1)
                            };

                            planClienteUpdated.AddUsuario(planDisponible);
                        }
                    }
                    #endregion                                       

                    planClienteRepository.SaveOrUpdate(planClienteUpdated);

                    return RedirectToAction("Basico");
                }

                InicializarCombosBasico(planCliente);
                return View(planCliente);
            }
            catch (PreconditionException ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
            catch (SessionExpiredException)
            {
                TempData["ErrorMessage"] = "Sesión Expirada!";
                TempData["Expire"] = true;
                return RedirectToAction("Error", "Shared");
            }
            catch (Exception ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
        }

        /// <summary>
        /// Inicializar combos basicos.
        /// </summary>
        /// <param name="planCliente"></param>
        private void InicializarCombosBasico(PlanCliente planCliente)
        {
            InicializarCombosPlanDisponible(planCliente);

            ViewData["CodigoPeridiocidad"] = new SelectList(
                peridiocidadRepository.GetAll(), "Id", "Nombre", planCliente.CodigoPeridiocidad);

            ViewData["CodigoIntervalo"] = new SelectList(
                intervaloRepository.GetAll(), "Id", "Nombre", planCliente.CodigoIntervalo);

            List<SelectListItem> condicion = new List<SelectListItem>()
            {
                new SelectListItem { Value = "1", Text = "Entrando" },
                new SelectListItem { Value = "2", Text = "Saliendo" },
                new SelectListItem { Value = "3", Text = "Entrada o salida" }
            };

            ViewData["Condicion"] = new SelectList(condicion, "Value", "Text", planCliente.Condicion);
        }

        /// <summary>
        /// Inicializar combos de planes disponibles
        /// </summary>
        /// <param name="planCliente"></param>
        private void InicializarCombosPlanDisponible(PlanCliente planCliente)
        {
            IList<Unidad> unidades = unidadRepository.GetDisponiblesByPlan(workingSession.Usuario.CodigoCliente, planCliente);
            IList<Grupo> grupos = usuarioRepository.GetDisponiblesByGrupo(workingSession.Usuario.CodigoCliente, planCliente);
            List<Helper> usuariosGrupos = new List<Helper>();

            grupos.ToList().ForEach(p => usuariosGrupos.Add(new Helper { Codigo = p.Id * -1, Nombre = '[' + p.Nombre + ']' }));
            unidades.ToList().ForEach(p => usuariosGrupos.Add(new Helper { Codigo = p.Id, Nombre = p.Nombre }));
            ViewData["usuariosDisponibles"] = new MultiSelectList(usuariosGrupos, "Codigo", "Nombre");

            IList<Unidad> unidadSeleccionados = unidadRepository.GetSeleccionadosByPlan(workingSession.Usuario.CodigoCliente, planCliente);
            IList<Grupo> gruposSeleccionados = usuarioRepository.GetSeleccionadosByGrupo(workingSession.Usuario.CodigoCliente, planCliente);
            List<Helper> usuariosGruposSeleccionados = new List<Helper>();

            gruposSeleccionados.ToList().ForEach(p => usuariosGruposSeleccionados.Add(new Helper { Codigo = p.Id * -1, Nombre = '[' + p.Nombre + ']' }));
            unidadSeleccionados.ToList().ForEach(p => usuariosGruposSeleccionados.Add(new Helper { Codigo = p.Id, Nombre = p.Nombre }));
            ViewData["usuariosSeleccionados"] = new MultiSelectList(usuariosGruposSeleccionados, "Codigo", "Nombre");
        }

        #endregion

        #region Plan avanzado

        /// <summary>
        /// Mostrar planes avanzados.
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Transaction, Authorize]
        public ActionResult Avanzado(int? id)
        {
            if (!usuarioRepository.IsInRole(User.Identity.Name, "admin,cliente"))
                return RedirectToAction("NoAutorizado", "Shared");

            try
            {
                Dictionary<string, object> filtro = new Dictionary<string,object>();
                filtro.Add("CodigoCliente", workingSession.Usuario.CodigoCliente);
                filtro.Add("CodigoPlan", null);
                IList<PlanCliente> planesCliente = planClienteRepository.FindAll(filtro);
                PagedList<PlanCliente> planesList = new PagedList<PlanCliente>(planesCliente, id ?? 1, 10);

                return View(planesList);
            }
            catch (PreconditionException ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
            catch (SessionExpiredException)
            {
                TempData["ErrorMessage"] = "Sesión Expirada!";
                TempData["Expire"] = true;
                return RedirectToAction("Error", "Shared");
            }
            catch (Exception ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }            
        }

        /// <summary>
        /// Invocado mediante AJAX para crear el nombre del Plan Avanzado
        /// </summary>
        /// <param name="id"></param>
        /// <param name="nombreHidden"></param>
        /// <returns></returns> 
        [Transaction, HttpPost, Authorize]
        public ActionResult Avanzado(int? id, string nombreHidden)
        {
            if (!usuarioRepository.IsInRole(User.Identity.Name, "admin,cliente"))
                return RedirectToAction("NoAutorizado", "Shared");

            try
            {
                PlanCliente planCliente = new PlanCliente()
                {
                    Cliente = workingSession.Usuario.Cliente,
                    Activo = true,
                    Resumen = false,
                    Nombre = nombreHidden
                };

                planClienteRepository.SaveOrUpdate(planCliente);

                return RedirectToAction("Avanzado");
            }
            catch (PreconditionException ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
            catch (SessionExpiredException)
            {
                TempData["ErrorMessage"] = "Sesión Expirada!";
                TempData["Expire"] = true;
                return RedirectToAction("Error", "Shared");
            }
            catch (Exception ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
        }

        /// <summary>
        /// Metodo GET para editar el plan
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Transaction, Authorize]
        public ActionResult NuevoPlan(int? id)
        {
            if (!usuarioRepository.IsInRole(User.Identity.Name, "admin,cliente"))
                return RedirectToAction("NoAutorizado", "Shared");
            try
            {
                Check.Require(id != null, "Id es incorrecto");
                PlanCliente planCliente = planClienteRepository.Get(id.Value);
                Check.Require(planCliente != null, "No se pudo recuperar los datos del plan");

                InicializarCombosAvanzado(planCliente);

                return View(planCliente);
            }
            catch (PreconditionException ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
            catch (SessionExpiredException)
            {
                TempData["ErrorMessage"] = "Sesión Expirada!";
                TempData["Expire"] = true;
                return RedirectToAction("Error", "Shared");
            }
            catch (Exception ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
        }

        /// <summary>
        /// Metodo POST para editar el plan
        /// </summary>
        /// <param name="Id"></param>
        /// <param name="planCliente"></param>
        /// <returns></returns>
        [Transaction, HttpPost, Authorize]
        public ActionResult NuevoPlan(int Id, PlanCliente planCliente)
        {
            if (!usuarioRepository.IsInRole(User.Identity.Name, "admin,cliente"))
                return RedirectToAction("NoAutorizado", "Shared");

            try
            {
                if (ModelState.IsValid && planCliente.IsValid())
                {
                    PlanCliente planClienteUpdated = planClienteRepository.Get(Id);
                    UpdateModel(planClienteUpdated);
                    
                    #region Agregar Usuarios
                    if (!string.IsNullOrEmpty(planCliente.UsuariosHidden))
                    {
                        string[] selectedUsuarios = planCliente.UsuariosHidden.Split(',');

                        // Insertar usuarios seleccionados
                        foreach (var item in selectedUsuarios)
                        {
                            PlanDisponible planDisponible = new PlanDisponible()
                            {
                                Unidad = Convert.ToInt32(item) > 0 ? unidadRepository.Get(Convert.ToInt32(item)) : null,
                                Grupo = Convert.ToInt32(item) > 0 ? null : grupoRepository.Get(Convert.ToInt32(item) * -1)
                            };

                            planClienteUpdated.AddUsuario(planDisponible);
                        }
                    }
                    #endregion                                       

                    planClienteRepository.SaveOrUpdate(planClienteUpdated);
                    return RedirectToAction("Avanzado");
                }

                InicializarCombosAvanzado(planCliente);

                return View(planCliente);
            }
            catch (PreconditionException ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
            catch (SessionExpiredException)
            {
                TempData["ErrorMessage"] = "Sesión Expirada!";
                TempData["Expire"] = true;
                return RedirectToAction("Error", "Shared");
            }
            catch (Exception ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
        }

        /// <summary>
        /// Metodo GET para editar plan avanzado
        /// </summary>
        /// <param name="Id"></param>
        /// <param name="codigoPlanCliente"></param>
        /// <returns></returns>
        [Transaction, Authorize]
        public ActionResult EditarPlanAvanzado(int? Id, int codigoPlanCliente)
        {
            if (!usuarioRepository.IsInRole(User.Identity.Name, "admin,cliente"))
                return RedirectToAction("NoAutorizado", "Shared");

            try
            {
                PlanEvento planEvento = new PlanEvento();
                int codigoTipoEvento;

                if (Id != null && Id.Value != 0)
                {
                    planEvento = planEventoRepository.Get(Id.Value);
                    Check.Require(planEvento != null, "No se pudo recuperar PlanEvento");
                    codigoTipoEvento = planEvento.CodigoTipoEvento;
                }
                else
                {
                    planEvento.CodigoPlanCliente = codigoPlanCliente;
                    codigoTipoEvento = 1;
                }

                TipoEvento tipoEvento = tipoEventoRepository.Get(codigoTipoEvento);
                Check.Require(tipoEvento != null, "No se pudo recuperar el nombre del evento");
                ViewData["NombreDetalle"] = tipoEvento.NombreDetalle;

                InicializarCombosPlanEvento(planEvento);

                return View(planEvento);
            }
            catch (PreconditionException ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
            catch (SessionExpiredException)
            {
                TempData["ErrorMessage"] = "Sesión Expirada!";
                TempData["Expire"] = true;
                return RedirectToAction("Error", "Shared");
            }
            catch (Exception ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
        }

        /// <summary>
        /// Metodo POST para editar plan avanzado.
        /// </summary>
        /// <param name="Id"></param>
        /// <param name="planEvento"></param>
        /// <returns></returns>
        [Transaction, HttpPost, Authorize]
        public ActionResult EditarPlanAvanzado(int? Id, PlanEvento planEvento)
        {
            if (!usuarioRepository.IsInRole(User.Identity.Name, "admin,cliente"))
                return RedirectToAction("NoAutorizado", "Shared");

            try
            {
                if (ModelState.IsValid && planEvento.IsValid())
                {
                    PlanEvento planEventoUpdated = planEvento;

                    if (Id != null && Id.Value != 0)
                    {
                        planEventoUpdated = planEventoRepository.Get(Id.Value);
                        UpdateModel(planEventoUpdated);
                    }

                    planEventoRepository.SaveOrUpdate(planEventoUpdated);
                    return RedirectToAction("NuevoPlan", new { Id = planEvento.CodigoPlanCliente });
                }
                
                InicializarCombosPlanEvento(planEvento);

                TipoEvento tipoEvento = tipoEventoRepository.Get(1);
                Check.Require(tipoEvento != null, "No se pudo recuperar el nombre del evento");

                ViewData["NombreDetalle"] = tipoEvento.NombreDetalle;

                return View(planEvento);
            }
            catch (PreconditionException ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
            catch (SessionExpiredException)
            {
                TempData["ErrorMessage"] = "Sesión Expirada!";
                TempData["Expire"] = true;
                return RedirectToAction("Error", "Shared");
            }
            catch (Exception ex)
            {
                TempData["ErrorMessage"] = ex.Message;
                return RedirectToAction("Error", "Shared");
            }
        }

        /// <summary>
        /// Eliminar Plan Avanzado. Llamada mediante AJAX
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Transaction, HttpPost, Authorize]
        public ActionResult EliminarPlanEvento(int id)
        {
            if (!usuarioRepository.IsInRole(User.Identity.Name, "admin,cliente"))
                return RedirectToAction("NoAutorizado", "Shared");

            try
            {
                PlanEvento planEvento = planEventoRepository.Get(id);
                Check.Require(planEvento != null, "No se pudo recuperar los datos");
                planEventoRepository.Delete(planEvento);
                planEventoRepository.DbContext.CommitTransaction();
                return Json("");
            }
            catch (PreconditionException)
            {
                return Json("Ha ocurrido un error en la aplicación. Por favor intente más tarde.");
            }
            catch (Exception)
            {
                return Json("El registro no pudo ser eliminado, posiblemente tenga relación con otra entidad.");
            }
        }

        /// <summary>
        /// Llamada AJAX para poblar los DropDownList
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost, Authorize]
        public ActionResult GetTipoDetalle(int id)
        {
            TipoEvento tipoEvento = tipoEventoRepository.Get(id);

            Dictionary<string, object> filtro = new Dictionary<string, object>();
            filtro.Add("TipoEvento.Id", id);

            IList<TipoDetalle> tipoDetalle = tipoDetalleRepository.FindAll(filtro);
            var resultDetalle = from u in tipoDetalle
                         select new
                         {
                             Codigo = u.Id.ToString(),
                             Nombre = u.Nombre
                         };
                        
            IList<TipoAlerta> tipoAlerta = tipoAlertaRepository.FindAll(filtro);
            var resultAlerta = from u in tipoAlerta
                         select new
                         {
                             Codigo = u.Id.ToString(),
                             Nombre = u.Nombre
                         };
            
            var result = new { Detalle = resultDetalle, Alerta = resultAlerta, Nombre = tipoEvento.NombreDetalle };

            return Json(result);
        }

        /// <summary>
        /// Llamada AJAX para poblar las alertas
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost, Authorize]
        public ActionResult GetTipoAlerta(int id)
        {
            Dictionary<string, object> filtro = new Dictionary<string, object>();
            filtro.Add("TipoEvento.Id", id);

            IList<TipoAlerta> tipoAlerta = tipoAlertaRepository.FindAll(filtro);
            var result = from u in tipoAlerta
                         select new
                         {
                             Codigo = u.Id.ToString(),
                             Nombre = u.Nombre
                         };

            return Json(result);
        }

        /// <summary>
        /// Inicializar combos
        /// </summary>
        /// <param name="planEvento"></param>
        private void InicializarCombosPlanEvento(PlanEvento planEvento)
        {
            IList<TipoEvento> tipoEvento = tipoEventoRepository.GetAll();
            ViewData["CodigoTipoEvento"] = new SelectList(tipoEvento, "Id", "Nombre", planEvento.CodigoTipoEvento);

            int codigoTipoEvento = planEvento.CodigoTipoEvento;
            if (codigoTipoEvento == 0)
                codigoTipoEvento = tipoEvento.FirstOrDefault().Id;

            Dictionary<string, object> filtro = new Dictionary<string,object>();
            filtro.Add("TipoEvento.Id", codigoTipoEvento);

            IList<TipoDetalle> tipoDetalle = tipoDetalleRepository.FindAll(filtro);
            ViewData["CodigoTipoDetalle"] = new SelectList(tipoDetalle, "Id", "Nombre", planEvento.CodigoTipoDetalle);

            IList<TipoAlerta> tipoAlerta = tipoAlertaRepository.FindAll(filtro);
            ViewData["CodigoTipoAlerta"] = new SelectList(tipoAlerta, "Id", "Nombre", planEvento.CodigoTipoAlerta);

            IList<Poligono> poligonos = new List<Poligono>();
            if (planEvento.CodigoTipoEvento == 1)
                poligonos = poligonoRepository.GetRutaByCliente(workingSession.Usuario.CodigoCliente);
            else
                poligonos = poligonoRepository.GetPoligonoByCliente(workingSession.Usuario.CodigoCliente);

            ViewData["CodigoPoligono"] = new SelectList(poligonos, "Id", "Nombre", planEvento.CodigoPoligono);

            List<SelectListItem> transmision = new List<SelectListItem>() 
                { 
                    new SelectListItem { Value = "1", Text="Ilimitado" },
                    new SelectListItem { Value = "2", Text="Una vez" }
                };

            ViewData["Transmision"] = new SelectList(transmision, "Value", "Text", planEvento.Transmision);

            List<SelectListItem> tipoTransmision = new List<SelectListItem>() 
                { 
                    new SelectListItem { Value = "1", Text="Inmediato" },
                    new SelectListItem { Value = "2", Text="Memoria" }
                };

            ViewData["TipoTransmision"] = new SelectList(tipoTransmision, "Value", "Text", planEvento.TipoTransmision);
        }
        
        /// <summary>
        /// Inicializar combos
        /// </summary>
        /// <param name="planCliente"></param>
        private void InicializarCombosAvanzado(PlanCliente planCliente)
        {
            InicializarCombosPlanDisponible(planCliente);
        }

        #endregion
               
    }
}
